/**
 * 字符串驼峰转任意符号连接
 * @param {string} str
 * @param {string} line
 */
export function humpTo(str, line = "_") {
  if (!str) {
    return "";
  }
  const newstr = str.substring(1, str.length);
  return (
    str[0].toLowerCase() +
    newstr.replace(/([A-Z])/g, function (match) {
      return line + match.toLowerCase();
    })
  );
}
/**
 * 字符串任意符号转为驼峰
 * @param {string} str
 * @param {string} line
 */
export function toCamel(str, line) {
  const reg = eval(`/([^${line}])(?:${line}+([^${line}]))/g`);
  return str.replace(reg, function ($0, $1, $2) {
    return $1 + $2.toUpperCase();
  });
}
/**
 * 通过id和pid返回树形结构数据
 * @param {Array} jsonData
 */
// export function getTreeData(jsonData: any[]) {
//   let returnResult: any[] = [];
//   //递归获取子级
//   function getChildren(nodeList: any[], jsonData: any[]) {
//     nodeList.forEach((elemet: any) => {
//       elemet.children = jsonData.filter((item: any) => {
//         return item.pid == elemet.id;
//       });
//       if (elemet.children.length > 0) {
//         elemet.hasChildrenNode = true;
//         getChildren(elemet.children, jsonData);
//       }
//     });
//     returnResult = nodeList;
//   }
//   //取得顶级的数据
//   const resultObj: any[] = [];
//   //先获取一遍所有数据的id,方便父级pid不是0或者没有的情况，获取第一层数据
//   // const ids = jsonData.map((item: any) => {
//   //   return item.id;
//   // })
//   const baseNode = jsonData.filter(function (element: any) {
//     return !element.pid;
//     // return (!element.pid || ids.indexOf(element.pid) < 0) && !element.meta?.query?.url;
//   });

//   resultObj.push(...baseNode);
//   getChildren(resultObj, jsonData);
//   return returnResult;
// }
/**
 * 判断数据类型
 * @param {any} param
 */
export function typeis(param) {
  const typeObj = {
    "[object Object]": "object",
    "[object Array]": "array",
    "[object String]": "string",
    "[object Boolean]": "boolean",
    "[object Number]": "number",
    "[object Null]": "null",
    "[object Undefined]": "undefined",
  };
  const type = Object.prototype.toString.call(param);
  return typeObj[type] ? typeObj[type] : "null";
}
/**
 * 转换数组中每条数据指定字段的类型
 * @param {string} type [要转换的类型]
 * @param {string|[]} data [要转换数据]
 * @param {any} params [指定要转换类型的字段名称]
 */
const typeTohandelObj = {
  string: function (val) {
    return val || val == "0" ? String(val) : "";
  },
  number: function (val) {
    return val || val == "0" ? Number(val) : "";
  },
};
export function turnToArray(data) {
  const datatype = typeis(data);
  return datatype == "array" ? data : [data];
}
/**
 * @description 转换数组或者对象中的数据类型，比如把数字类型转换为字符串类型
 * @param type 要转换成什么类型
 * @param data 转换的数据
 * @param params 转换什么字段
 * @returns
 */
export function turnType(type, data, ...params) {
  // 判断传入的数据类型，object或者array
  const datatype = typeis(data);
  const newData = datatype == "object" ? [data] : data;
  const fieldnames = params;
  newData.map((item) => {
    fieldnames.map((name) => {
      item[name] = typeTohandelObj[type](item[name]);
    });
  });
  return datatype == "array" ? newData : newData[0];
}

/**
 * @description 格式化数据（有些字段名称和需要的不符，所以要转化一下）
 * @param data 要转换的数组
 * @param filedRule 转换规则 格式{text:name,userId:id} text为原来的字段，name为要转化成的字段,可填写多个
 * @returns
 */
export function changeFiled(data, filedRule) {
  data.map((item) => {
    for (const key in item) {
      if (filedRule[key]) {
        const changeFiled = filedRule[key];
        item[changeFiled] = item[key];
      }
    }
  });
  return data;
}

/**
 * @description 兼容key类型，比较是否存在于某个数组中，因为indexOf必须类型也相同
 * 如果能确定类型唯一不需要用这个方法
 * @param key 要检查是否在某个数组中的值
 * @param arr 要检查的数组
 * @returns boolean
 */
export function checkKeyinArr(key, arr) {
  return !(
    arr.indexOf(key) < 0 &&
    arr.indexOf(String(key)) < 0 &&
    arr.indexOf(Number(key)) < 0
  );
}
export function trim(text) {
  if (!text) return false;
  const newtext = text + "";
  return newtext.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
}
// 获取uuid
export function getUID() {
  return "xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx".replace(/[xy]/g, function (c) {
    var r = (Math.random() * 16) | 0,
      v = c == "x" ? r : (r & 0x3) | 0x8;
    return v.toString(16);
  });
}
